// class Point {
//   public x: number | undefined
//   public y: number | undefined

//   constructor(x: number, y: number) {
//     this.x = x
//     this.y = y
//   }

//   public getPosition () {
//     return `(${this.x}, ${this.y})`
//   }
// }

// const point = new Point(1, 2)
// console.log(point);

// class Parent {
//   public name: string | undefined
//   constructor(name: string) {
//     this.name = name
//   } 
// }

// class Child extends Parent {
//   constructor(name: string) {
//     super(name)
//   }
// }


// public 公共的

// private  私有的

// protected 受保护的

// class Parent{
//   private age: number | undefined
//   constructor(age: number) {
//     this.age = age
//   }
// }

// const p = new Parent(18)
// console.log(p);
// console.log(Parent.age);  // 报错，类本身同样拿不到age属性
// console.log(p.age);  // 报错，实例对象拿不到age属性


// class Parent{
//   protected age: number | undefined
//   constructor(age: number) {
//     this.age = age
//   }
//   protected getAge() {
//     return this.age
//   }
// }

// const p = new Parent(18)
// // console.log(p);  
// // console.log(p.age);  // 实例上同样拿不到受保护的属性
// // console.log(p.getAge());  // 实例上同样拿不到受保护的方法

// class Child extends Parent {
//   constructor(age: number) {
//     super(age)
//     // console.log(super.age);  // 拿不到受保护的属性
//     console.log(super.getAge());  // 受保护方法可以拿到
//   }
// }

// const ci = new Child(18)

// class Info {
//   public name: string | undefined
//   public age?: number 
//   private _infoStr: string | undefined
//   constructor (name: string, age?: number, public sex?: string) {
//     this.name = name
//     this.age = age

//   }
//   get infoStr() {
//     return this._infoStr
//   }
//   set infoStr(value) {
//     console.log(`setter: ${value}`);
//     this._infoStr = value
//   }
// }

// const info = new Info('lison', 18, 'man')
// info.infoStr = 'lison: 18'
// console.log(info.infoStr );

// // abstract  抽象类
// abstract class People {
//   constructor(public name: string) {}
//   public abstract printName(): void
// }

// // const p1 = new People() // 报错，不能直接创建抽象类实例
// class Man extends People {
//   constructor(name: string) {
//     super(name)
//     this.name = name
//   }
//   public printName() {
//     console.log(this.name);    
//   }
// }

// const m = new Man('lison')
// m.printName()


// abstract class People{
//   public abstract _name: string
  
//   abstract get insideName(): string
//   abstract set insideName(value: string)

// }

// class P extends People{
//   public _name: string
//   constructor(name: string) {
//     super()
//     this._name = name;
//   }
//   public get insideName(): string {
//     return this._name
//   }
// }

class People {
  constructor(public name: string) {}
}
let p2: People = new People('lison')

class Animal {
  constructor(public name: string) {}
}

p2 = new Animal('haha')

console.log(p2 instanceof People);

// 不能判断实例是继承那个class的， instanceof

// interface FoodInterFace {
//   type: string;
// }

// class FoodClass implements FoodInterFace{
//   public type: string
//   constructor(type: string) {
//     this.type = type
//   }
// }

// // 以上是类继承接口

class A {
  protected name: string | undefined
}

interface I extends A {}      // 接口继承类, 只继承成员

// class B implements I {}  // 类继承接口的方法implements

class B extends A implements I {
  public name: string
  constructor(name: string) {
    super()
    this.name = name
  }
}

const create = <T>(c: new() => T): T => {
  return new c()
}

class Infos {
  public age: number | undefined
}

console.log(create<Infos>(Infos));



